package server;
import java.io.IOException;
import java.util.ArrayList;

/** Classe che si occupa della gestione della Mappa della partita.
 *
 */
public class Mappa{
	
	/** Numero di righe della Mappa. E' di tipo FINAL e quindi non puo' essere modificato.
	 * 
	 */
	public static final int SIZE_X=40; /*final: non esiste comando che modifichi SIZE_X. */
	
	/** Numero di colonne della Mappa. E' di tipo FINAL e quindi non puo' essere modificato.
	 * 
	 */
	public static final int SIZE_Y=40;
	
	private String[][] mappa = new String[SIZE_X][SIZE_Y];
	private ArrayList<Casella> acqua = new ArrayList<Casella>();
	private static ArrayList<Casella> terra = new ArrayList<Casella>();
	private ArrayList<Vegetazione> vegetazione = new ArrayList<Vegetazione>();
	private ArrayList<Carogna> carogna = new ArrayList<Carogna>();
	
	private int numAMax=(int)(SIZE_X*SIZE_Y*0.2);
	private int numCMax=20;
	private int numVMax=(int)((SIZE_X*SIZE_Y - numAMax)*0.4);
	
	private int numA=0;
	private int numC=0;
	private int numV=0;
	private int numT=0;
	
	/**
	 * Costruttore dell'oggetto Mappa. Quando viene chiamato controlla in automatico l'esistenza di
	 * un file da caricare altrimenti genera una mappa random secondo le specifiche.
	 */
	@SuppressWarnings("unchecked")
	public Mappa(){
		//cerco se i file sono salvati
		try{

			mappa = (String[][])(Salvataggio.carica("mappa"));
			acqua = (ArrayList<Casella>)(Salvataggio.carica("acqua"));
			terra = (ArrayList<Casella>)(Salvataggio.carica("terra"));
			vegetazione = (ArrayList<Vegetazione>)(Salvataggio.carica("vegetazione"));
			carogna = (ArrayList<Carogna>)(Salvataggio.carica("carogna"));
			
			System.out.println("Mappa caricata da file.");
			
			
		}catch (IOException e) {
			System.out.println("File della mappa non trovati, generata una nuova mappa.");
			generaMappa();
		}catch (ClassNotFoundException e) {
//			System.out.println("Classe non trovata.");
			generaMappa();
		}
	}

	/**Metodo che genera la mappa secondo le specifiche sotto riportate.
	 * Acqua: 156 intorno all'isola, 164 per le pozze divise in gruppi da 5 a 15 caselle (l'acqua non divide la mappa in due porzioni)
	 * Terra: 748
	 * Vegetazione: 512 
	 * Carogne: 20
	 * Setta gli attributi mappa, acqua, terra, vegetazione, carogna 
	 */
	
	private void generaMappa(){
		
		for(int r=0; r<SIZE_X; r++){
			for (int c=0; c<SIZE_Y; c++){
				
				if(r==0 || r==(SIZE_X -1) || c==0 || c==(SIZE_Y -1) ){ 

					//crea un contorno d'acqua
					addAcqua(r, c);
					numA++;
					
				}else if(r==1 || r==SIZE_X - 2 || c==1 || c== SIZE_Y -2){
					String tipo = scegliTipo();
					if(tipo.compareTo("t")==0){
						//creo un contorno di terra, di vegetazione o carogne
						addTerra(r,c);
						numT++;
					}else if(tipo.compareTo("v")==0){
						addVegetazione(r, c);
						numV++;
					}else{
						addCarogna(r, c);
						numC++;
					}
				}
				else{
					mappa[r][c]="u:0";
				}
			}
		}
		
		//aggiungo le pozze d'acqua
		while(numA<numAMax){
			int numAIns=5+(int)Math.round(Math.random()*10);
			
			//quando mancano meno di 20 pozze da inserire assegno manualmente numAins (le celle A, da inserire)
			if((numAMax-numA)<=20){
				if((numAMax-numA)<=15){
					numAIns=numAMax-numA;
				}else{
					numAIns=5;
				}
			}
			
			int xRand=0;
			int yRand=0;
			boolean result;
			//scelgo la cella da cui far partire insertPozzaFiore
			
			while(getTipoCella(xRand, yRand).compareTo("u")!=0){
				xRand=(int)Math.round(Math.random()*(SIZE_X - 2));
				yRand=(int)Math.round(Math.random()*(SIZE_Y - 2));
			}
			result=insertPozzaFiore(numAIns, xRand, yRand);
			
			if(result){
				numA=numA+numAIns;
			}
		}

		//inserisco le carogne
		while(numC<numCMax){
			int xRand=0;
			int yRand=0;
			
			while(getTipoCella(xRand, yRand).compareTo("u")!=0){
				xRand=(int)Math.round(Math.random()*(SIZE_X - 1));
				yRand=(int)Math.round(Math.random()*(SIZE_Y - 1));
			}

			addCarogna(xRand, yRand);
			numC++;
		}
		
		//inserisco la vegetazione
		
		while(numV<numVMax){
			int xRand=0;
			int yRand=0;
			
			while(getTipoCella(xRand, yRand).compareTo("u")!=0){
				xRand=(int)Math.round(Math.random()*(SIZE_X - 1));
				yRand=(int)Math.round(Math.random()*(SIZE_Y - 1));
			}
			
			addVegetazione(xRand, yRand);
			numV++;
		}
		
		//completo la mappa inserendo tutte le caselle terra
		
		for(int r=0; r<SIZE_X; r++){
			for (int c=0; c<SIZE_Y; c++){
				if(getTipoCella(r,c).compareTo("u")==0){
					addTerra(r,c);
				}
			}
		}
		
		salvaMappa();

	}
	
	/**
	 * Metodo che inserisce le pozze d'acqua evitando che esse dividino la mappa in due parti.
	 * @param numA Numero di celle d'acqua da creare
	 * @param xStart Coordinata x da cui parte l'algoritmo
	 * @param yStart Coordinata y da cui parte l'algoritmo
	 * @return Valore booleano che comunica l'avvenuto inserimento della pozza o l'impossibilita' di inserire la stessa.
	 */
	private boolean insertPozzaFiore(int numA, int xStart, int yStart){
		ArrayList<Integer> idFioreA = new ArrayList<Integer>(); //indice delle celle a aggiunte;
		ArrayList<Integer> idFioreT = new ArrayList<Integer>(); //indice delle celle t aggiunte;
		ArrayList<Integer> idFioreC = new ArrayList<Integer>(); //indice delle celle c aggiunte;
		ArrayList<Integer> idFioreV = new ArrayList<Integer>(); //indice delle celle v aggiunte;
		
		int numAIns=0;
		
		addAcqua(xStart, yStart);
		idFioreA.add(acqua.size() - 1);
		numAIns++;
		
		for(int i=0; i<idFioreA.size(); i++){
			
			int nextRand=(int)Math.round((Math.random()*3)); //scelta random per partire a scansire le celle da nord, est, sud o ovest
			boolean primaA = true;
			for(int j=0; j<4; j++){
				int x = 0;
				int y = 0;
				int xNext = 0;
				int yNext = 0;
				switch(nextRand){
					//nord
					case 0:
						x=acqua.get(idFioreA.get(i)).getX() - 1;
						y=acqua.get(idFioreA.get(i)).getY();
						xNext = x - 1;
						yNext = y;
						break;
					//est
					case 1:
						x=acqua.get(idFioreA.get(i)).getX();
						y=acqua.get(idFioreA.get(i)).getY() + 1;
						xNext = x;
						yNext = y + 1;
						break;
					//sud
					case 2:
						x=acqua.get(idFioreA.get(i)).getX() + 1;
						y=acqua.get(idFioreA.get(i)).getY();
						xNext = x + 1;
						yNext = y;
						break;
					//ovest
					case 3:
						x=acqua.get(idFioreA.get(i)).getX();
						y=acqua.get(idFioreA.get(i)).getY() - 1;
						xNext = x;
						yNext = y - 1;
						break;
				}
				if(numAIns<numA){
					int at = (int)Math.round((Math.random()*3));
					if(mappa[x][y].compareTo("u:0")==0){
						//controllo la cella d'"avanti"
						//Se la cella e' libera inserisco l'acqua o la terra
						if((primaA || at!=0) && mappa[xNext][yNext].substring(0, 1).compareTo("a")!=0){
							addAcqua(x, y);
							idFioreA.add(acqua.size() - 1);
							numAIns++;
							primaA = false;
						}else{
							String tipo = scegliTipo();
							if(tipo.compareTo("t")==0){
								addTerra(x,y);
								idFioreT.add(terra.size() - 1);
								numT++;
							}else if(tipo.compareTo("v")==0){
								addVegetazione(x, y);
								idFioreV.add(vegetazione.size() - 1);
								numV++;
							}else{
								addCarogna(x, y);
								idFioreC.add(carogna.size() - 1);
								numC++;
							}
						}
					}
				}else{
					if(mappa[x][y].compareTo("u:0")==0){
						//Se la cella e' libera e sono finite le acque da inserire inserisco la terra
						String tipo = scegliTipo();
						if(tipo.compareTo("t")==0){
							addTerra(x,y);
							idFioreT.add(terra.size() - 1);
							numT++;
						}else if(tipo.compareTo("v")==0){
							addVegetazione(x, y);
							idFioreV.add(vegetazione.size() - 1);
							numV++;
						}else{
							addCarogna(x, y);
							idFioreC.add(carogna.size() - 1);
							numC++;
						}
					}
				}
			
				nextRand++;
				
				if(nextRand==4){
					nextRand=0;
				}
			}
		}
		if(numAIns==numA){
			return true;
		}else{

			//se sono qui dentro vuol dire che numAIns<numA quindi devo annullare le operazioni fatte e ritornare false
			//cancellare celle A e celle T inserite
			for (int i=0; i<idFioreA.size(); i++){
				removeAcqua();
			}
			for (int i=0; i<idFioreT.size(); i++){
				removeTerra();
				numT--;
			}
			for (int i=0; i<idFioreV.size(); i++){
				removeVegetazione();
				numV--;
			}
			for (int i=0; i<idFioreC.size(); i++){
				removeCarogna();
				numC--;
			}
			return false;
		}
	}
	
	/**
	 * Metodo che ritorna un tipo tra terra, vegetazione e carogna
	 * @return Ritorna una stringa con la lettera corrispondente t - terra, v - vegetazione, c - carogna
	 */
	
	private String scegliTipo(){
		int numRand = (int)Math.round(Math.random()*(((SIZE_X)*(SIZE_Y) - numAMax - numVMax - numCMax) - numT + numCMax - numC + numVMax - numV));
		if(numRand<((SIZE_X)*(SIZE_Y) - numAMax - numVMax) - numT){
			return "t";
		}else if(numRand<((SIZE_X)*(SIZE_Y) - numAMax - numVMax) - numT + numVMax - numV){
			return "v";
		}else{
			return "c";
		}
	}

	
	/**
	 * Meotodo che aggiunge una casella di tipo Acqua nelle coordinate x, y.
	 * @param x Coordinata X per la casella
	 * @param y Coordinata Y per la casella
	 */
	private void addAcqua(int x, int y){
		acqua.add(new Casella("A", x, y));		
		mappa[x][y]="a:"+(acqua.size()-1);
	}
	
	/**
	 * Metodo che rimuove l'ultima casella di tipo Acqua inserita.
	 */
	private void removeAcqua(){
		int id = acqua.size() - 1;
		mappa[acqua.get(id).getX()][acqua.get(id).getY()]="u:0";
		acqua.remove(id);
	}
	
	/**
	 * Meotodo che aggiunge una casella di tipo Terra nelle coordinate x, y.
	 * @param x Coordinata X per la casella
	 * @param y Coordinata Y per la casella
	 */
	private void addTerra(int x, int y){
		terra.add(new Casella("T", x, y));
		mappa[x][y]="t:"+(terra.size() - 1);
	}
	
	/**
	 * Metodo che rimuove l'ultima casella di tipo Terra inserita.
	 */
	private void removeTerra(){
		int id = terra.size() - 1;
		mappa[terra.get(id).getX()][terra.get(id).getY()]="u:0";
		terra.remove(id);
	}
	
	/**
	 * Meotodo che aggiunge una casella di tipo Carogna nelle coordinate x, y.
	 * @param x Coordinata X per la casella
	 * @param y Coordinata Y per la casella
	 */
	private void addCarogna(int x, int y){
		carogna.add(new Carogna(x, y));
		mappa[x][y]="c:"+(carogna.size() - 1);
	}
	
	/**
	 * Metodo che rimuove l'ultima casella di tipo Carogna inserita.
	 */
	private void removeCarogna(){
		int id = carogna.size() - 1;
		mappa[carogna.get(id).getX()][carogna.get(id).getY()]="u:0";
		carogna.remove(id);
	}
	
	/**
	 * Meotodo che aggiunge una casella di tipo Vegetazione nelle coordinate x, y.
	 * @param x Coordinata X per la casella
	 * @param y Coordinata Y per la casella
	 */
	private void addVegetazione(int x, int y){
		vegetazione.add(new Vegetazione(x, y));
		mappa[x][y]="v:"+(vegetazione.size() - 1);
	}
	
	/**
	 * Metodo che rimuove l'ultima casella di tipo Vegetazione inserita.
	 */
	private void removeVegetazione(){
		int id = vegetazione.size() - 1;
		mappa[vegetazione.get(id).getX()][vegetazione.get(id).getY()]="u:0";
		vegetazione.remove(id);
	}
	
	/**
	 * Metodo che ritorna il tipo di cella con coordinate x, y
	 * @param x Coordinata x della cella
	 * @param y Coordinata y della cella
	 * @return Carattere corrispondente al tipo di cella t - terra, a - acqua, v - vegetazione, c - carogna
	 */
	private String getTipoCella(int x, int y){
		return mappa[x][y].substring(0,1);
	}
	
	/**
	 * Metodo che controlla la possibilita' di movimento del dinosauro in posizione xStart, yStart dalla casella stessa
	 * alla casella xEnd, yEnd.<br />
	 * Metodo testato in testMappa.
	 * @param xStart Coordinata x del dinosauro
	 * @param yStart Coordinata y del dinosauro
	 * @param xEnd Coordinata x della destinazione
	 * @param yEnd Coordinata y della destinazione
	 * @return
	 */
	public int checkMovimento(int xStart, int yStart, int xEnd, int yEnd){
		Dinosauro dino = getCasella(xStart, yStart).getDinosauro();
		if(dino==null){
			return -1;
		}
		int numMosseMax = dino.getMovimento();
		ArrayList<Casella> casToCheck = new ArrayList<Casella>();
		ArrayList<Integer> mosseNec = new ArrayList<Integer>();
		
		casToCheck.add(getCasella(xStart, yStart));
		mosseNec.add(0);
		while(!(casToCheck.isEmpty()) && mosseNec.get(0) < numMosseMax){
			int x = casToCheck.get(0).getX();
			int y = casToCheck.get(0).getY();
			for(int i=0; i<8; i++){
				Casella tmpCas = null;
				switch(i){
					case 0:
						tmpCas = getCasella(x - 1, y);
						break;
					case 1:
						tmpCas = getCasella(x - 1, y + 1);
						break;
					case 2:
						tmpCas = getCasella(x, y + 1);
						break;
					case 3:
						tmpCas = getCasella(x + 1, y + 1);
						break;
					case 4:
						tmpCas = getCasella(x + 1, y);
						break;
					case 5:
						tmpCas = getCasella(x + 1, y - 1);
						break;
					case 6:
						tmpCas = getCasella(x, y - 1);
						break;
					case 7:
						tmpCas = getCasella(x - 1, y - 1);
						break;
				}
				if(tmpCas.getTipo().compareTo("A")!=0){
					
					if(tmpCas.getX() == xEnd && tmpCas.getY() == yEnd){
						return (mosseNec.get(0) + 1);
					}else if(casToCheck.indexOf(tmpCas)==-1){
						casToCheck.add(tmpCas);
						mosseNec.add(mosseNec.get(0) + 1);
					}
				}
			}
			casToCheck.remove(0);
			mosseNec.remove(0);
		}
		
		return -1;
		
	}
	
	/**
	 * Metodo che ritorna un Array contenete la vista locale del dinosauro in posizione xDino, yDino.
	 * Metodo testato in testMappa.
	 * @param xDino Coordinata x del dinosauro
	 * @param yDino Coordinata y del dinosauro
	 * @param vista Numero di caselle intorno al dinosauro
	 * @param nascosto Nasconde o meno le caselle di tipo c - carogna e i dinosauri
	 * @return <code><b>String[][]</b> mappaLocale</code>
	 */
	public String[][] getMappaLocale(int xDino, int yDino, int vista, boolean nascosto){
		if(xDino < 0 || yDino < 0 || xDino>=SIZE_X || yDino>= SIZE_Y){
			return null;
		}
		
		int xStart = xDino - vista;
		int yStart = yDino - vista;
		int xEnd = xDino + vista;
		int yEnd = yDino + vista;
		
		if(xStart<0){
			xStart=0;
		}
		
		if(yStart<0){
			yStart=0;
		}
		
		if(xEnd>(SIZE_X - 1)){
			xEnd=SIZE_X - 1;
		}
		
		if(yEnd>(SIZE_Y - 1)){
			yEnd=SIZE_Y - 1;
		}
		
		int x=0;
		int y=0;
		String lettera="";
		String numero="";
		String[][] mappaLocale = new String[xEnd-xStart + 1][yEnd-yStart + 1];
		do{
			do{
				Casella casella = getCasella(xStart + x, yStart + y);
				if(casella.getDinosauro()!=null && !(nascosto)){
					if(casella.getDinosauro().getTipo()=='c'){
						lettera="D";
					}else{
						lettera="d";
					}
					numero=","+casella.getDinosauro().getIdDino();
				}else if(casella.getTipo().compareTo("A")==0){
					lettera="a";
				}else if(casella.getTipo().compareTo("T")==0){
					lettera="t";
				}else if(casella.getTipo().compareTo("V")==0){
					Vegetazione veg = (Vegetazione)casella;
					lettera="v";
					numero=","+veg.getEnergia();
				}else if(casella.getTipo().compareTo("C")==0 && !(nascosto)){
					Carogna car = (Carogna)casella;
					lettera="c";
					numero=","+car.getEnergia();
				}else{
					lettera="t";
				}
				if( nascosto ){
					numero = "";
				}
				mappaLocale[x][y]=lettera+numero;
				numero="";
				x++;
				
			}while(x <= xEnd-xStart && x<SIZE_X);
			x=0;
			y++;
		}while(y <= yEnd- yStart && y<SIZE_Y);
		return mappaLocale;
	}

	/**
	 * Metodo che ritorna tutta la mappa generale senza dinosauri. Non ha una funzione all'interno del gioco, e'
	 * un metodo solo di test.
	 * @return <code><b>String[][]</b> mappaGenerale</code>
	 */
	public String[][] getMappaGenerale(){
		
		String[][] mappaGenerale = new String[SIZE_X][SIZE_Y];
		int x=0;
		int y=0;
		String lettera="";
		String energia="";
		do{
			do{
				if(mappa[x][y].substring(0, 1).compareTo("c")==0){
					lettera="b";//mappa[x][y].substring(0, 1);
					energia=","+carogna.get(Integer.parseInt(mappa[x][y].substring(2))).getEnergia();
				}else if(mappa[x][y].substring(0, 1).compareTo("v")==0){
					lettera=mappa[x][y].substring(0, 1);
					energia=","+vegetazione.get(Integer.parseInt(mappa[x][y].substring(2))).getEnergia();
				}else if(mappa[x][y].substring(0, 1).compareTo("t")==0){
					lettera=mappa[x][y].substring(0, 1);
				}else if(mappa[x][y].substring(0, 1).compareTo("a")==0){
					lettera=mappa[x][y].substring(0, 1);
				}
				
				mappaGenerale[x][y]=lettera+energia;
				energia="";
				x++;
				
			}while(x<SIZE_X);
			x=0;
			y++;
		}while(y<SIZE_Y);
		return mappaGenerale;
	}
	
	/**
	 * Metodo che ritorna una oggetto di tipo Casella non occupato
	 * @return
	 */
	public Casella getCasellaLibera(){
		int idTRand;
		
		do{
			idTRand=(int)(Math.round(Math.random()*(terra.size()-1)));
		}while(terra.get(idTRand).getOccupata());
		return terra.get(idTRand);
	}
	
	/**
	 * Metodo che controlla se la Casella in x,y e' occupata o meno.
	 * @param x Coordinata X della Casella
	 * @param y Coordinata Y della Casella
	 * @return  <code><b>Boolean</b> occupata</code>
	 */
	public boolean occupata(int x, int y){
		String tipo = mappa[x][y].substring(0, 1);
		int id = Integer.parseInt(mappa[x][y].substring(2));
		if(tipo.compareTo("c")==0){
			return carogna.get(id).getOccupata();
		}else if(tipo.compareTo("t")==0){
			return terra.get(id).getOccupata();
		}else if(tipo.compareTo("v")==0){
			return vegetazione.get(id).getOccupata();
		}else{
			return acqua.get(id).getOccupata();
		}
	}
	
	/**
	 * Metodo che ritorna l'oggetto di tipo Casella con coordinate x, y. 
	 * @param x Coordinata X della Casella
	 * @param y Coordinata Y della Casella
	 * @return Oggetto Casella corrispondente
	 */
	public Casella getCasella(int x, int y){
		String tipo=mappa[x][y].substring(0,1);
		if(tipo.compareTo("a")==0){
			return acqua.get(Integer.parseInt(mappa[x][y].substring(2)));
		}else if(tipo.compareTo("t")==0){
			return terra.get(Integer.parseInt(mappa[x][y].substring(2)));
		}else if(tipo.compareTo("v")==0){
			return vegetazione.get(Integer.parseInt(mappa[x][y].substring(2)));
		}else if(tipo.compareTo("c")==0){
			return carogna.get(Integer.parseInt(mappa[x][y].substring(2)));
		}else{
			return null;
		}
	}
	
	/**
	 * Metodo che sposta una casella di tipo Carogna con una Casella di tipo Terra. 
	 * @param x Coordinata X della casella di tipo Carogna
	 * @param y Coordinata Y della casella di tipo Carogna
	 * @return Ritorna il risultato dello spostamento. Se <code>false</code> 
	 * le coordinate passate non si riferiscono ad una Carogna.
	 */
	public boolean spostaCarogna(int x, int y){
		if(mappa[x][y].substring(0,1).compareTo("c")==0){
			Casella tRand = getCasellaLibera();
			
			//scambio lettere in mappa
			int xTRand=tRand.getX();
			int yTRand=tRand.getY();

			String codT=mappa[xTRand][yTRand];
			String codC=mappa[x][y];

			mappa[xTRand][yTRand] = codC;
			mappa[x][y] = codT;
			
			//scambio coordinate negli array
			int idC=Integer.parseInt(codC.substring(2));
			tRand.scambiaCasella(carogna.get(idC));
			
			//rigenero la carogna
			carogna.get(idC).reinizializzaEnergia();
			
			return true;
		}else{
			return false;
		}
	}
	
	/**
	 * Metodo che evolve la mappa: aumento l'energia della vegetazione e dimunisce l'energia delle carogne 
	 * ed eventualmente cambia la loro posizione. 
	 */
	public void evolvi(){
		//evolvo la vegetazione
		for (int i=0; i<vegetazione.size(); i++) {
			vegetazione.get(i).crescita();
		}
		
		//evolvo le carogne ed eventualmente le sposto
		for (int i=0; i<carogna.size(); i++) {
			carogna.get(i).deperimento();
			if(carogna.get(i).getEnergia()==0){
				spostaCarogna(carogna.get(i).getX(), carogna.get(i).getY());
			}
		}
	}
	
	@SuppressWarnings("unchecked")
	public Boolean salvaMappa(){
		try{
			Salvataggio.salva(mappa, "mappa");
			Salvataggio.salva(acqua, "acqua");
			
			Salvataggio.salva(terra, "tmpTerra");
			Salvataggio.salva(vegetazione, "tmpVegetazione");
			Salvataggio.salva(carogna, "tmpCarogna");
			
			ArrayList<Casella> terraDaSal = (ArrayList<Casella>) Salvataggio.carica("tmpTerra");
			ArrayList<Casella> vegetazioneDaSal = (ArrayList<Casella>) Salvataggio.carica("tmpVegetazione");
			ArrayList<Casella> carognaDaSal = (ArrayList<Casella>) Salvataggio.carica("tmpCarogna");
			
			for(int i=0; i<3; i++){
				switch(i){
				case 0:
					for(int j=0; j<terraDaSal.size(); j++){
						Casella tmpCas = terraDaSal.get(j);
						tmpCas.setOccupata(false);
						tmpCas.insertDinosauro(null);
					}
					break;
				case 1:
					for(int j=0; j<vegetazioneDaSal.size(); j++){
						Casella tmpCas = vegetazioneDaSal.get(j);
						tmpCas.setOccupata(false);
						tmpCas.insertDinosauro(null);
					}
					break;
				case 2:
					for(int j=0; j<carognaDaSal.size(); j++){
						Casella tmpCas = carognaDaSal.get(j);
						tmpCas.setOccupata(false);
						tmpCas.insertDinosauro(null);
					}
					break;
				}
			}
			
			Salvataggio.salva(terraDaSal, "terra");
			Salvataggio.salva(vegetazioneDaSal, "vegetazione");
			Salvataggio.salva(carognaDaSal, "carogna");
			Salvataggio.elimina("tmpTerra");
			Salvataggio.elimina("tmpVegetazione");
			Salvataggio.elimina("tmpCarogna");
			
			return true;
		}catch (IOException e) {
			System.out.println("Mappa: Errore nel salvataggio.");
			return false;
		}catch (ClassNotFoundException e) {
			System.out.println("Mappa: Errore nel salvataggio.");
			return false;
		}
	}
}